1class SubscriptionTier(Enum):
2    FREE = "FREE"
3    PREMIUM = "PREMIUM"
4
5class PlayerStatus(Enum):
6    PLAYING = "PLAYING"
7    PAUSED = "PAUSED"
8    STOPPED = "STOPPED"

1class Playable(ABC):
2    @abstractmethod
3    def get_tracks(self) -> List['Song']:
4        pass

1class Song(Playable):
2    def __init__(self, song_id: str, title: str, artist: 'Artist', duration_in_seconds: int):
3        self._id = song_id
4        self._title = title
5        self._artist = artist
6        self._duration_in_seconds = duration_in_seconds
7    
8    def get_tracks(self) -> List['Song']:
9        return [self]
10    
11    def __str__(self) -> str:
12        return f"'{self._title}' by {self._artist.get_name()}"
13    
14    @property
15    def id(self) -> str:
16        return self._id
17    
18    @property
19    def title(self) -> str:
20        return self._title
21    
22    @property
23    def artist(self) -> 'Artist':
24        return self._artist

1class Album(Playable):
2    def __init__(self, title: str):
3        self._title = title
4        self._tracks: List[Song] = []
5    
6    def add_track(self, song: Song):
7        self._tracks.append(song)
8    
9    def get_tracks(self) -> List[Song]:
10        return self._tracks.copy()
11    
12    def get_title(self) -> str:
13        return self._title

1class Playlist(Playable):
2    def __init__(self, name: str):
3        self._name = name
4        self._tracks: List[Song] = []
5    
6    def add_track(self, song: Song):
7        self._tracks.append(song)
8    
9    def get_tracks(self) -> List[Song]:
10        return self._tracks.copy()

1class ArtistObserver(ABC):
2    @abstractmethod
3    def update(self, artist: 'Artist', new_album: 'Album'):
4        pass
5
6class Subject:
7    def __init__(self):
8        self._observers: List[ArtistObserver] = []
9    
10    def add_observer(self, observer: ArtistObserver):
11        self._observers.append(observer)
12    
13    def remove_observer(self, observer: ArtistObserver):
14        if observer in self._observers:
15            self._observers.remove(observer)
16    
17    def notify_observers(self, artist: 'Artist', album: 'Album'):
18        for observer in self._observers:
19            observer.update(artist, album)

1class Artist(Subject):
2    def __init__(self, artist_id: str, name: str):
3        super().__init__()
4        self._id = artist_id
5        self._name = name
6        self._discography: List['Album'] = []
7    
8    def release_album(self, album: 'Album'):
9        self._discography.append(album)
10        print(f"[System] Artist {self._name} has released a new album: {album.get_title()}")
11        self.notify_observers(self, album)
12    
13    @property
14    def id(self) -> str:
15        return self._id
16    
17    def get_name(self) -> str:
18        return self._name

1class User(ArtistObserver):
2    def __init__(self, user_id: str, name: str, playback_strategy: PlaybackStrategy):
3        self._id = user_id
4        self._name = name
5        self._playback_strategy = playback_strategy
6        self._followed_artists: Set[Artist] = set()
7    
8    def follow_artist(self, artist: Artist):
9        self._followed_artists.add(artist)
10        artist.add_observer(self)
11    
12    def update(self, artist: Artist, new_album: Album):
13        print(f"[Notification for {self._name}] Your followed artist {artist.get_name()} "
14              f"just released a new album: {new_album.get_title()}!")
15    
16    @property
17    def playback_strategy(self) -> PlaybackStrategy:
18        return self._playback_strategy
19    
20    @property
21    def id(self) -> str:
22        return self._id
23    
24    def get_name(self) -> str:
25        return self._name
26    
27    class Builder:
28        def __init__(self, name: str):
29            self._id = str(uuid.uuid4())
30            self._name = name
31            self._playback_strategy = None
32        
33        def with_subscription(self, tier: SubscriptionTier, songs_played: int) -> 'User.Builder':
34            self._playback_strategy = PlaybackStrategy.get_strategy(tier, songs_played)
35            return self
36        
37        def build(self) -> 'User':
38            return User(self._id, self._name, self._playback_strategy)

1class Player:
2    def __init__(self):
3        self._state = StoppedState()
4        self._status = PlayerStatus.STOPPED
5        self._queue: List[Song] = []
6        self._current_index = -1
7        self._current_song: Optional[Song] = None
8        self._current_user: Optional[User] = None
9    
10    def load(self, playable: Playable, user: User):
11        self._current_user = user
12        self._queue = playable.get_tracks()
13        self._current_index = 0
14        print(f"Loaded {len(self._queue)} tracks for user {user.get_name()}.")
15        self._state = StoppedState()
16    
17    def play_current_song_in_queue(self):
18        if 0 <= self._current_index < len(self._queue):
19            song_to_play = self._queue[self._current_index]
20            self._current_user.playback_strategy.play(song_to_play, self)
21    
22    def click_play(self):
23        self._state.play(self)
24    
25    def click_pause(self):
26        self._state.pause(self)
27    
28    def click_next(self):
29        if self._current_index < len(self._queue) - 1:
30            self._current_index += 1
31            self.play_current_song_in_queue()
32        else:
33            print("End of queue.")
34            self._state.stop(self)
35    
36    def change_state(self, state: PlayerState):
37        self._state = state
38    
39    def set_status(self, status: PlayerStatus):
40        self._status = status
41    
42    def set_current_song(self, song: Song):
43        self._current_song = song
44    
45    def has_queue(self) -> bool:
46        return len(self._queue) > 0

1class PlayerState(ABC):
2    @abstractmethod
3    def play(self, player: 'Player'):
4        pass
5    
6    @abstractmethod
7    def pause(self, player: 'Player'):
8        pass
9    
10    @abstractmethod
11    def stop(self, player: 'Player'):
12        pass
13
14class PausedState(PlayerState):
15    def play(self, player: 'Player'):
16        print("Resuming playback.")
17        player.change_state(PlayingState())
18        player.set_status(PlayerStatus.PLAYING)
19    
20    def pause(self, player: 'Player'):
21        print("Already paused.")
22    
23    def stop(self, player: 'Player'):
24        print("Stopping playback from paused state.")
25        player.change_state(StoppedState())
26        player.set_status(PlayerStatus.STOPPED)
27
28class PlayingState(PlayerState):
29    def play(self, player: 'Player'):
30        print("Already playing.")
31    
32    def pause(self, player: 'Player'):
33        print("Pausing playback.")
34        player.change_state(PausedState())
35        player.set_status(PlayerStatus.PAUSED)
36    
37    def stop(self, player: 'Player'):
38        print("Stopping playback.")
39        player.change_state(StoppedState())
40        player.set_status(PlayerStatus.STOPPED)
41
42class StoppedState(PlayerState):
43    def play(self, player: 'Player'):
44        if player.has_queue():
45            print("Starting playback.")
46            player.change_state(PlayingState())
47            player.set_status(PlayerStatus.PLAYING)
48            player.play_current_song_in_queue()
49        else:
50            print("Queue is empty. Load songs to play.")
51    
52    def pause(self, player: 'Player'):
53        print("Cannot pause. Player is stopped.")
54    
55    def stop(self, player: 'Player'):
56        print("Already stopped.")

1class PlaybackStrategy(ABC):
2    @abstractmethod
3    def play(self, song: Song, player: 'Player'):
4        pass
5    
6    @staticmethod
7    def get_strategy(tier: SubscriptionTier, songs_played: int) -> 'PlaybackStrategy':
8        if tier == SubscriptionTier.PREMIUM:
9            return PremiumPlaybackStrategy()
10        else:
11            return FreePlaybackStrategy(songs_played)
12
13class FreePlaybackStrategy(PlaybackStrategy):
14    SONGS_BEFORE_AD = 3
15    
16    def __init__(self, initial_songs_played: int):
17        self._songs_played = initial_songs_played
18    
19    def play(self, song: Song, player: 'Player'):
20        if self._songs_played > 0 and self._songs_played % self.SONGS_BEFORE_AD == 0:
21            print("\n>>> Playing Advertisement: 'Buy Spotify Premium for ad-free music!' <<<\n")
22        player.set_current_song(song)
23        print(f"Free User is now playing: {song}")
24        self._songs_played += 1
25
26class PremiumPlaybackStrategy(PlaybackStrategy):
27    def play(self, song: Song, player: 'Player'):
28        player.set_current_song(song)
29        print(f"Premium User is now playing: {song}")

1class RecommendationStrategy(ABC):
2    @abstractmethod
3    def recommend(self, all_songs: List[Song]) -> List[Song]:
4        pass
5
6class GenreBasedRecommendationStrategy(RecommendationStrategy):
7    def recommend(self, all_songs: List[Song]) -> List[Song]:
8        print("Generating genre-based recommendations (simulated)...")
9        shuffled = all_songs.copy()
10        random.shuffle(shuffled)
11        return shuffled[:5]

1class Command(ABC):
2    @abstractmethod
3    def execute(self):
4        pass
5
6class PlayCommand(Command):
7    def __init__(self, player: Player):
8        self._player = player
9    
10    def execute(self):
11        self._player.click_play()
12
13class PauseCommand(Command):
14    def __init__(self, player: Player):
15        self._player = player
16    
17    def execute(self):
18        self._player.click_pause()
19
20class NextTrackCommand(Command):
21    def __init__(self, player: Player):
22        self._player = player
23    
24    def execute(self):
25        self._player.click_next()

1class RecommendationService:
2    def __init__(self, strategy: RecommendationStrategy):
3        self._strategy = strategy
4    
5    def set_strategy(self, strategy: RecommendationStrategy):
6        self._strategy = strategy
7    
8    def generate_recommendations(self, all_songs: List[Song]) -> List[Song]:
9        return self._strategy.recommend(all_songs)

1class SearchService:
2    def search_songs_by_title(self, songs: List[Song], query: str) -> List[Song]:
3        return [s for s in songs if query.lower() in s.title.lower()]
4    
5    def search_artists_by_name(self, artists: List[Artist], query: str) -> List[Artist]:
6        return [a for a in artists if query.lower() in a.get_name().lower()]

1class MusicStreamingSystem:
2    _instance = None
3    _lock = threading.Lock()
4    
5    def __new__(cls):
6        if cls._instance is None:
7            with cls._lock:
8                if cls._instance is None:
9                    cls._instance = super().__new__(cls)
10                    cls._instance._initialized = False
11        return cls._instance
12    
13    def __init__(self):
14        if not self._initialized:
15            self._users: Dict[str, User] = {}
16            self._songs: Dict[str, Song] = {}
17            self._artists: Dict[str, Artist] = {}
18            self._player = Player()
19            self._search_service = SearchService()
20            self._recommendation_service = RecommendationService(GenreBasedRecommendationStrategy())
21            self._initialized = True
22    
23    @classmethod
24    def get_instance(cls):
25        return cls()
26    
27    def register_user(self, user: User):
28        self._users[user.id] = user
29    
30    def add_song(self, song_id: str, title: str, artist_id: str, duration: int) -> Song:
31        song = Song(song_id, title, self._artists[artist_id], duration)
32        self._songs[song.id] = song
33        return song
34    
35    def add_artist(self, artist: Artist):
36        self._artists[artist.id] = artist
37    
38    def search_songs_by_title(self, title: str) -> List[Song]:
39        return self._search_service.search_songs_by_title(list(self._songs.values()), title)
40    
41    def get_song_recommendations(self) -> List[Song]:
42        return self._recommendation_service.generate_recommendations(list(self._songs.values()))
43    
44    def get_player(self) -> Player:
45        return self._player

1class MusicStreamingDemo:
2    @staticmethod
3    def main():
4        system = MusicStreamingSystem.get_instance()
5        
6        # --- Setup Catalog ---
7        daft_punk = Artist("art1", "Daft Punk")
8        system.add_artist(daft_punk)
9        
10        discovery = Album("Discovery")
11        s1 = system.add_song("s1", "One More Time", daft_punk.id, 320)
12        s2 = system.add_song("s2", "Aerodynamic", daft_punk.id, 212)
13        s3 = system.add_song("s3", "Digital Love", daft_punk.id, 301)
14        s4 = system.add_song("s4", "Radioactive", daft_punk.id, 311)
15        discovery.add_track(s1)
16        discovery.add_track(s2)
17        discovery.add_track(s3)
18        discovery.add_track(s4)
19        
20        # --- Register Users (Builder Pattern) ---
21        free_user = User.Builder("Alice").with_subscription(SubscriptionTier.FREE, 0).build()
22        premium_user = User.Builder("Bob").with_subscription(SubscriptionTier.PREMIUM, 0).build()
23        system.register_user(free_user)
24        system.register_user(premium_user)
25        
26        # --- Observer Pattern: User follows artist ---
27        print("--- Observer Pattern Demo ---")
28        premium_user.follow_artist(daft_punk)
29        daft_punk.release_album(discovery)  # This will notify Bob
30        print()
31        
32        # --- Strategy Pattern: Playback behavior ---
33        print("--- Strategy Pattern (Free vs Premium) & State Pattern (Player) Demo ---")
34        player = system.get_player()
35        player.load(discovery, free_user)
36        
37        # --- Command Pattern: Controlling the player ---
38        play = PlayCommand(player)
39        pause = PauseCommand(player)
40        next_track = NextTrackCommand(player)
41        
42        play.execute()  # Plays song 1
43        next_track.execute()  # Plays song 2
44        pause.execute()  # Pauses song 2
45        play.execute()  # Resumes song 2
46        next_track.execute()  # Plays song 3
47        next_track.execute()  # Plays song 4 (ad for free user)
48        print()
49        
50        # --- Premium user experience (no ads) ---
51        print("--- Premium User Experience ---")
52        player.load(discovery, premium_user)
53        play.execute()
54        next_track.execute()
55        print()
56        
57        # --- Composite Pattern: Play a playlist ---
58        print("--- Composite Pattern Demo ---")
59        my_playlist = Playlist("My Awesome Mix")
60        my_playlist.add_track(s3)  # Digital Love
61        my_playlist.add_track(s1)  # One More Time
62        
63        player.load(my_playlist, premium_user)
64        play.execute()
65        next_track.execute()
66        print()
67        
68        # --- Search and Recommendation ---
69        print("--- Search and Recommendation Service Demo ---")
70        search_results = system.search_songs_by_title("love")
71        print(f"Search results for 'love': {search_results}")
72        
73        recommendations = system.get_song_recommendations()
74        print(f"Your daily recommendations: {recommendations}")
75
76if __name__ == "__main__":
77    MusicStreamingDemo.main()